home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / com / computer / midi_com / sourcen / mc_drive.mid / mcdrv2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-17  |  12.2 KB  |  631 lines
  1. #include <stddef.h>
  2. #include <tos.h>
  3. #include <string.h>
  4. #include <screen.h>
  5. #include    "mcdrv1.h"
  6. #include "cookie.h"
  7.  
  8.  
  9. #define TIMER    ((long *) 0x4baL)
  10.  
  11. #define  anmeldung    0
  12. #define    id_request    1
  13. #define    new_appl        2
  14. #define    err_bell        3
  15. #define    stop            4
  16. #define    start            5
  17. #define    storno        6
  18.  
  19. #define sync_size 10
  20. #define tok_size  10
  21. #define err_size    10
  22. #define headsize  10
  23.  
  24. #define taste() Bconin(2)
  25.  
  26. /* defines for Reader */
  27.  
  28. typedef struct 
  29. {
  30.     int    (*SENDE)(int an,int LEN,char *buff);
  31.     int    (*REPLY)(int LEN,char *buff);
  32.     int    (*LESE)(int *len,char *buff);
  33.     int    (*CMD)(int cmd,int *par1,int *par2);
  34.     char    *unused2;
  35. }io_port;
  36.  
  37. typedef struct
  38. {
  39.     int        sync_id;
  40.     boolean    s_status;
  41.     boolean    broken;
  42.     char    tnum;
  43. }status;
  44.  
  45. status    state={0,FALSE,FALSE,0};
  46.  
  47. static    int    SENDER(int an,int LEN,char *buff);
  48. static    int    REPLY(int LEN,char *buff);
  49. static    int    READER(int *len,char *buff);
  50. static    int    CMD(int cmd,int *par1,int *par2);
  51. io_port  port={SENDER,REPLY,READER,CMD,NULL};
  52.  
  53. typedef struct
  54. {
  55.     int    frei:8;
  56.     int    erg:2;
  57.     int    doubl:1;
  58.     int    reply:1;
  59.     int    von:4;
  60. }r_wert;
  61.  
  62. typedef union bit_conv
  63. {
  64.     int        as_int;
  65.     r_wert    as_bits;
  66. }bit_conv;
  67.  
  68. bit_conv    return_wert;
  69.  
  70. #define RFALSE    0x0000
  71. #define RTRUE    0x0040
  72. #define RFAIL    0x00C0
  73.  
  74. typedef struct
  75. {
  76.     int    size;
  77.     char    id;
  78.     char    von;
  79.     int    an;
  80.     unsigned int    crc_data;
  81.     unsigned int    crc_head;
  82.     char    *buff;
  83. } packet;
  84.  
  85. char    buffer[4500];
  86.  
  87. #define BP _BasPag
  88.  
  89. packet    spacket={0,0,0,0,0,0,buffer};
  90. packet    rpacket={0,0,0,0,0,0,NULL};
  91.  
  92. char        my_num=7;
  93. int            STATE=0;
  94. boolean        num_locked=FALSE;
  95. boolean        new_sync=FALSE;
  96. boolean      sync_rast=FALSE;
  97. boolean      XREPLY=FALSE;
  98. int            last_sync;
  99. long        last_msg;
  100. int            time_out=4;
  101.  
  102. /* Hilfsfunktionen */
  103.  
  104. #define for_me(a)    (a&(1<<my_num))
  105. #define set_bit(b,a) (b|(1<<a))
  106. #define reset_bit(b,a) (b & ~(1<<a))
  107. #define pruef_bit(b,a) (b & (1<<a))
  108.  
  109. extern unsigned int make_crc(char *buf,int len);
  110.  
  111. /* Ende Hilfsfunktionen */
  112. /*
  113. void out(const char *zeile,int wert)
  114. {
  115. char str[32];
  116. Cconws(MCTR);
  117. Cconws(" ");
  118. itoa(my_num,str,10);
  119. Cconws(str);
  120. Cconws(" ");
  121. Cconws(zeile);
  122. Cconws(" ");
  123. itoa(wert,str,10);
  124. Cconws(str);
  125. Cconws("\r\n");
  126. }
  127. */
  128. int    search_bit(int bits)
  129. {
  130.     int i;
  131.     for (i=6;i>=0;i--)
  132.     {
  133.         if (!pruef_bit(bits,i)) return(i);
  134.     }
  135.     return(-1);
  136. }
  137.  
  138.  
  139. void    SYNC_RECIEVED(void)
  140. {
  141. int i;
  142. int hlp;
  143.     new_sync=TRUE;
  144.     if (rpacket.an==127)
  145.     {
  146.         rpacket.von='P';
  147.     }
  148.     else
  149.     {
  150.         if (!num_locked)
  151.         {
  152.             my_num=search_bit(rpacket.an);
  153.             rpacket.an=set_bit(rpacket.an,my_num);
  154.             sync_rast=TRUE;
  155.         }
  156.         else
  157.         {
  158.             i=search_bit(rpacket.an);
  159.             if (i!=my_num)
  160.             {
  161.                 sync_rast=FALSE;
  162.                 hlp=last_sync;
  163.                 last_sync=rpacket.an;
  164.             }
  165.             if (i<my_num)
  166.             {
  167.                 rpacket.an=(127 & (hlp<<1));
  168.                 last_sync=rpacket.an;
  169.             }
  170.             else
  171.             {
  172.                 if (i==my_num)
  173.                 {
  174.                     sync_rast=TRUE;
  175.                     rpacket.an=set_bit(rpacket.an,my_num);
  176.                     i=my_num;i--;
  177.                     while (i>=0)
  178.                     {
  179.                         rpacket.an=reset_bit(rpacket.an,i--);
  180.                     }
  181.                 }
  182.             }
  183.         }
  184.     }
  185.     STATE=0;
  186.     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  187.     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  188. }
  189.  
  190. void    PRUEF_RECIEVED(void)
  191. {
  192.     switch(STATE)
  193.     {
  194.         case 0:    if (sync_rast)    STATE=1;
  195.                     else
  196.                     {
  197.                         rpacket.von='S';
  198.                         rpacket.an=(127 & (last_sync<<1));
  199.                         rpacket.size=sync_size;
  200.                         STATE=0;
  201.                     }
  202.                     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  203.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  204.                     break;
  205.         case 1:    if (my_num==0)
  206.                     {
  207.                         rpacket.von='T';
  208.                         rpacket.size=tok_size;
  209.                         rpacket.id=++state.tnum;
  210.                         rpacket.crc_head=make_crc((char*)&rpacket,8);    
  211.                     }
  212.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  213.                     break;
  214.         case 2:    rpacket.von='S';
  215.                     rpacket.an=0;
  216.                     rpacket.size=sync_size;
  217.                     STATE=0;
  218.                     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  219.                     SENDE(sync_size,(char *)&rpacket); /*weitegeben */
  220.                     break;
  221.     }
  222. }
  223.  
  224. void    TOKEN_RECIEVED(void)
  225. {
  226.     switch(STATE)
  227.     {
  228.         case 0:    rpacket.von='S';
  229.                     rpacket.an=0;
  230.                     rpacket.size=sync_size;
  231.                     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  232.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  233.                     break;
  234.         case 1:    num_locked=TRUE;
  235.                     state.tnum=rpacket.id;
  236.                     rpacket.size=sync_size;
  237.                     STATE=2;
  238.                     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  239.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  240.                     break;
  241.         case 2:    time_out=0;
  242.                     if (rpacket.id==state.tnum)
  243.                     {
  244.                         if (state.s_status==TRUE)
  245.                         {
  246.                             SENDE(10,(char *)&spacket);
  247.                             SENDE(spacket.size-10,spacket.buff);
  248.                             proto_out(spacket.buff,spacket.von, spacket.an,1);
  249.                         }
  250.                         SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  251.                     }
  252.                     else
  253.                     {
  254.                         if (my_num!=0)
  255.                         {
  256.                             state.tnum=rpacket.id;
  257.                             SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  258.                         }
  259.                     }
  260.                     break;
  261.     }
  262. }
  263.  
  264.  
  265. void    ERROR_RECIEVED(void)
  266. {
  267.     switch(STATE)
  268.     {
  269.         case 0:    rpacket.von='S';
  270.                     rpacket.size=sync_size;
  271.                     rpacket.an=0;
  272.                     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  273.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  274.                     break;
  275.         case 1:    rpacket.von='S';
  276.                     rpacket.size=sync_size;
  277.                     rpacket.an=0;
  278.                     STATE=0;
  279.                     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  280.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  281.                     break;
  282.         case 2:    if (my_num==0)
  283.                     {
  284.                         rpacket.von='T';
  285.                         rpacket.size=tok_size;
  286.                         rpacket.id=(char) ++state.tnum;
  287.                         rpacket.crc_head=make_crc((char*)&rpacket,8);    
  288.                     }
  289.                     SENDE(tok_size,(char *)&rpacket); /*weitegeben */
  290.                     break;
  291.     }
  292. }
  293.  
  294. void rec_error(int err_crc)
  295. {
  296.     clear_buff();
  297.     rpacket.von='E';
  298.     rpacket.an=0;
  299.     rpacket.size=err_size;
  300.     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  301.     SENDE(err_size,(char *)&rpacket); /*senden */
  302.     err_out(TRUE,err_crc);
  303. }
  304.  
  305.  
  306. void intern_msg(void)
  307. {
  308.     switch(rpacket.von)
  309.     {
  310.     case 'T':
  311.             TOKEN_RECIEVED();
  312.         break;
  313.     case 'S':
  314.             SYNC_RECIEVED();
  315.         break;
  316.     case 'E':
  317.             ERROR_RECIEVED();
  318.         break;
  319.     case 'P':    /* PRUEF-Message */
  320.             PRUEF_RECIEVED();
  321.          break;
  322.     case 'B':  /* BREAK */
  323.         {/* Time_out-Behandlung abschalten 
  324.             READER auf DAUER-FAIL */
  325.             state.broken=TRUE;
  326.             time_out=4;
  327.             SENDE(rpacket.size,(char *)&rpacket); /*weitegeben */
  328.         } /* case 'B' */
  329.         break;
  330.     default:rec_error(FALSE);
  331.     }
  332. }
  333.  
  334. int my_mail(int *len,char *buff)
  335. {  /* Anfrage oder REPLY */
  336.  
  337.     XREPLY=TRUE;
  338.     return_wert.as_int=0;
  339.  
  340.     *len=rpacket.size-10;
  341.     return_wert.as_bits.von=rpacket.von;
  342.  
  343.     if (lese(*len,buff)) 
  344.     {
  345.         rec_error(FALSE);
  346.         return(RFALSE);
  347.     }
  348.  
  349.     if (rpacket.crc_data != make_crc(buff,*len)) 
  350.     {
  351.         rec_error(TRUE);
  352.         return(RFALSE);
  353.     }
  354.  
  355.     err_out(FALSE,FALSE);
  356.                 
  357.     if (rpacket.von==my_num)
  358.     {
  359.         XREPLY=FALSE;
  360.         state.s_status=FALSE;
  361.         return_wert.as_bits.doubl=FALSE;
  362.         return_wert.as_bits.reply=TRUE;
  363.         proto_out(buff,rpacket.von, rpacket.an,2);
  364.     }
  365.     else
  366.     {
  367.         proto_out(buff,rpacket.von, rpacket.an,3);
  368.         return_wert.as_bits.doubl=FALSE;
  369.         return_wert.as_bits.reply=FALSE;
  370.         rpacket.an=reset_bit(rpacket.an,my_num);
  371.         if (rpacket.an!=0)
  372.         { /* Broadcast weitergeben*/
  373.             if (rpacket.an==0x0080) 
  374.             {
  375.                 rpacket.size=12;
  376.                 rpacket.crc_data=make_crc(buff,2);
  377.             }
  378.             rpacket.crc_head=make_crc((char*)&rpacket,8);    
  379.             SENDE(10,(char *)&rpacket);
  380.             SENDE(rpacket.size-10,buff);
  381.         }
  382.     }
  383.         
  384.     return(return_wert.as_int | RTRUE);
  385. }
  386.  
  387.  
  388.  
  389. int    READER(int *len,char *buff)
  390. {
  391.  
  392.     /* 1. lesen eines Blocks */
  393.     XREPLY=FALSE;
  394.     if (fil_request())
  395.     { /* Bytes im Buffer */
  396.         last_msg=*TIMER;
  397.         state.broken=FALSE;
  398.         if (lese(10,(char *)&rpacket))
  399.         { /* fehlerbehandlung */
  400.             rec_error(FALSE);
  401.             return(RFALSE);
  402.         }
  403.         /* 10 Bytes sind da oder Fehler */
  404.         if (rpacket.crc_head!=make_crc((char*)&rpacket,8))
  405.         {
  406.             rec_error(TRUE);
  407.             return(RFALSE);
  408.         }
  409.         if (rpacket.size==10)
  410.         {    /* Sonderpakete */
  411.             intern_msg();
  412.             err_out(FALSE,FALSE);
  413.             return(RFALSE);
  414.         } /* ende Sonderpakete */
  415.         else
  416.         {
  417.             if (for_me(rpacket.an) || (rpacket.von==my_num))
  418.                 return(my_mail(len,buff));
  419.             else
  420.             {
  421.                 *len=rpacket.size-10;
  422.                 if (lese(*len,buff)) 
  423.                 {
  424.                     rec_error(FALSE);
  425.                     return(RFALSE);
  426.                 }
  427.                 err_out(FALSE,FALSE);
  428.                 proto_out(buff,rpacket.von, rpacket.an,5);
  429.                 SENDE(headsize,(char *) &rpacket);
  430.                 SENDE(*len,buff);
  431.                 return(RFALSE);
  432.             }
  433.         }
  434.     }
  435.     else
  436.     {
  437.         if (((*TIMER-last_msg)>3000) && (num_locked) )
  438.         {
  439.             last_msg=*TIMER;
  440.             
  441.             if (!state.broken)
  442.             {time_out++;
  443.              if (my_num==0) 
  444.              {
  445.               rec_error(FALSE);
  446.              }
  447.             }
  448.         }
  449.         if (time_out>3) return(RFAIL);
  450.     }
  451.     return(RFALSE);
  452. }
  453.  
  454. int reciever_anz(int an) 
  455. {
  456.     register i=0,j=0;
  457.     for (i=0;i<7;i++) 
  458.         if (pruef_bit(an,i)) j++;
  459.     return(j);
  460. }
  461.  
  462. int    SENDER(int an,int LEN,char *buff)
  463. {
  464.     proto_out(buff,my_num,an,0);
  465.     if (state.s_status==TRUE)
  466.     {
  467.         Cconws("MIDI_COM ERROR !!!!\r\n");
  468.         Cconws("NEUE SENDUNG UEBERSCHREIBT Vorhandene\r\n");
  469.         Bconstat(2);
  470.         return(FAIL);
  471.     }
  472.     if (LEN>4400)
  473.     {
  474.         Cconws("MIDI_COM ERROR !!!!\r\n");
  475.         Cconws("UNSINNIGE SENDEGR™SSE\r\n");
  476.         Bconstat(2);
  477.         return(FAIL);
  478.     }
  479.     if (reciever_anz(an)==1)
  480.         spacket.an=an;
  481.     else     spacket.an=set_bit(an,7); /* Broadcast-Flag */
  482.     spacket.an &= 0x00FF;
  483.     spacket.size=LEN+10;
  484.     spacket.crc_data=make_crc(buff,LEN);
  485.     spacket.von=(char)my_num;
  486.     memcpy(spacket.buff,buff,(long)LEN);
  487.     spacket.crc_head=make_crc((char*)&spacket,8);    
  488.     return(state.s_status=TRUE);
  489. }
  490.  
  491. int    REPLY(int LEN,char *buff)
  492. {
  493.     if (LEN>4500)
  494.     {
  495.         Cconws("MIDI_COM ERROR !!!!\r\n");
  496.         Cconws("REPLY zu GROSS !!!!\r\n");
  497.         Cconws("BITTE HIER BOOTEN\r\n");
  498.         Bconstat(2);
  499.     }
  500.     if (! XREPLY)
  501.     {
  502.         Cconws("MIDI_COM ERROR !!!!\r\n");
  503.         Cconws(">>>>>>>>>>>UNDEFINIERTER REPLY !!!!\r\n");
  504.         Cconws("BITTE HIER BOOTEN\r\n");
  505.         Bconstat(2);
  506.     }
  507.     rpacket.an=0;
  508.     rpacket.size=LEN+10;
  509.     rpacket.crc_data=make_crc(buff,LEN);
  510.     rpacket.crc_head=make_crc((char*)&rpacket,8);    
  511.     proto_out(buff,rpacket.von, rpacket.an,4);
  512.     SENDE(headsize,(char *) &rpacket);
  513.     SENDE(LEN,buff);
  514.     return(0);
  515. }
  516.  
  517. /* Commandshell */
  518. int    CMD(int cmd,int *par1,int *par2)
  519. {
  520.     switch (cmd)
  521.     {
  522.     case    anmeldung : AES_install();
  523.                             clear_buff();
  524.                             my_num=7;
  525.                             STATE=0;
  526.                             num_locked=FALSE;
  527.                             new_sync=FALSE;
  528.                             time_out=4;
  529.                             rpacket.von='S';
  530.                             rpacket.an=0;
  531.                             rpacket.size=sync_size;
  532.                             rpacket.crc_head=make_crc((char*)&rpacket,8);    
  533.                             SENDE(sync_size,(char *) &rpacket);
  534.                             return(0);
  535.     case    new_appl:    if (new_sync)
  536.                             { 
  537.                                 new_sync=FALSE;
  538.                                   return(TRUE);
  539.                             }
  540.                             else
  541.                             return(FALSE);
  542.     case    err_bell:    set_errbell(par1);
  543.                             return(0);
  544.     case    id_request: if (num_locked) return(my_num);
  545.                                 else return(FAIL);
  546.     case    stop:            state.broken=TRUE;
  547.                             clear_buff();
  548.                             rpacket.von='B';
  549.                             rpacket.an=-1;
  550.                             rpacket.size=sync_size;
  551.                             rpacket.crc_head=make_crc((char*)&rpacket,8);    
  552.                             SENDE(sync_size,(char *) &rpacket);
  553.                             if (num_locked && (time_out<=3))
  554.                             {
  555.                                 do {state.broken=TRUE;} while (!fil_request());
  556.                             }
  557.                             clear_buff();
  558.                             time_out=4;
  559.                             break;
  560.     case    start:        state.broken=FALSE;
  561.                             time_out=0;
  562.                             rec_error(FALSE);
  563.                             break;
  564.     case    storno:        state.s_status=FALSE;
  565.                             break;
  566.     default:        return(-15);
  567.     }
  568.     return(0);
  569. }
  570. /* ende Commandshell */
  571.  
  572. /* Cookie-Teil */
  573. static long install_cookies(void)
  574. {
  575.     COOKIE  *cokie;
  576.     long    found=0;
  577.     int        i=16;
  578.         
  579.     cokie=*CJAR;
  580.     if (!cokie)
  581.     {
  582.         *CJAR=cokie=Malloc(i*8);
  583.         if (cokie)
  584.         {
  585.             cokie->tag.aslong = 0;
  586.             cokie->value=i;
  587.         }
  588.     }
  589.     if (cokie) 
  590.     {
  591.         while (cokie->tag.aslong != 0) 
  592.         {
  593.             if (!strncmp(cokie->tag.aschar, MCTR,4))
  594.             {
  595.                 cokie->value=(long)&port;
  596.                 found=1;
  597.             }
  598.             cokie++;
  599.         }
  600.         if (!found)
  601.         {
  602.             strncpy(cokie->tag.aschar,MCTR,4);
  603.             found=cokie->value;
  604.             cokie->value=(long) &port;
  605.             cokie++;
  606.             cokie->tag.aslong = 0; 
  607.             cokie->value=found; 
  608.         }
  609.         return(0);
  610.     }
  611.     return(FAIL);
  612. }
  613.  
  614. /* ende COOKIES */
  615.  
  616. long premiere(void)
  617. {
  618.     do_install();
  619.     (void)install_cookies();
  620.     last_msg=*TIMER;
  621.     return(0);
  622. }
  623.  
  624. void main(void)
  625. {
  626.     Cconws("Schnittstellentreiber\r\n");
  627.     Cconws("     --MIDI--\r\n");
  628.     Cconws("  fr MIDI_COM.ACC\r\n");
  629.     (void)Supexec(premiere);
  630.     Ptermres(256L + BP->p_tlen + BP->p_dlen + BP->p_blen, 0);
  631. }